"""K8s提取器日志管理模块"""

import os
import logging
from logging.handlers import RotatingFileHandler, TimedRotatingFileHandler
import sys
from typing import Dict, Any, Optional

class Logger:
    """
    K8s提取器的日志管理类
    支持控制台和文件输出，并支持日志轮转
    """
    
    # 日志级别映射
    LOG_LEVELS = {
        'debug': logging.DEBUG,
        'info': logging.INFO,
        'warning': logging.WARNING,
        'error': logging.ERROR,
        'critical': logging.CRITICAL
    }
    
    # 日志格式
    DEFAULT_LOG_FORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
    
    # 默认配置
    DEFAULT_CONFIG = {
        'level': 'info',
        'format': DEFAULT_LOG_FORMAT,
        'console': True,
        'file': True,
        'file_path': 'logs/k8s_extractor.log',
        'max_size': 10 * 1024 * 1024,  # 10 MB
        'backup_count': 5,
        'rotation': 'size',  # 'size' 或 'time'
        'when': 'D',  # 按天轮转，如果rotation为'time'
        'encoding': 'utf-8'
    }
    
    def __init__(self, config: Optional[Dict[str, Any]] = None, name: str = 'k8s_extractor'):
        """
        初始化日志管理器
        
        Args:
            config: 日志配置字典，可选，如果未提供则使用默认配置
            name: 日志器名称
        """
        self.config = self._merge_configs(config)
        self.name = name
        self.logger = logging.getLogger(name)
        
        # 设置日志级别
        self.logger.setLevel(self._get_log_level())
        
        # 避免重复处理器
        self.logger.handlers = []
        
        # 添加处理器
        self._setup_handlers()
    
    def _merge_configs(self, config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
        """合并自定义配置和默认配置"""
        if config is None:
            return self.DEFAULT_CONFIG.copy()
        
        merged = self.DEFAULT_CONFIG.copy()
        merged.update(config)
        return merged
    
    def _get_log_level(self) -> int:
        """获取日志级别"""
        level = self.config.get('level', 'info').lower()
        return self.LOG_LEVELS.get(level, logging.INFO)
    
    def _setup_handlers(self) -> None:
        """设置日志处理器"""
        log_format = self.config.get('format', self.DEFAULT_LOG_FORMAT)
        formatter = logging.Formatter(log_format)
        
        # 添加控制台处理器
        if self.config.get('console', True):
            console_handler = logging.StreamHandler(sys.stdout)
            console_handler.setFormatter(formatter)
            self.logger.addHandler(console_handler)
        
        # 添加文件处理器
        if self.config.get('file', True):
            self._setup_file_handler(formatter)
    
    def _setup_file_handler(self, formatter: logging.Formatter) -> None:
        """设置文件日志处理器"""
        file_path = self.config.get('file_path', 'logs/k8s_extractor.log')
        
        # 确保日志目录存在
        log_dir = os.path.dirname(file_path)
        if not os.path.exists(log_dir):
            os.makedirs(log_dir, exist_ok=True)
        
        # 选择轮转方式
        rotation = self.config.get('rotation', 'size')
        encoding = self.config.get('encoding', 'utf-8')
        
        if rotation == 'size':
            # 按大小轮转
            max_size = self.config.get('max_size', 10 * 1024 * 1024)
            backup_count = self.config.get('backup_count', 5)
            
            handler = RotatingFileHandler(
                file_path, 
                maxBytes=max_size,
                backupCount=backup_count,
                encoding=encoding
            )
        else:
            # 按时间轮转
            when = self.config.get('when', 'D')
            backup_count = self.config.get('backup_count', 5)
            
            handler = TimedRotatingFileHandler(
                file_path,
                when=when,
                backupCount=backup_count,
                encoding=encoding
            )
        
        handler.setFormatter(formatter)
        self.logger.addHandler(handler)
    
    def get_logger(self) -> logging.Logger:
        """获取配置好的日志记录器"""
        return self.logger
    
    def debug(self, message: str) -> None:
        """
        记录DEBUG级别日志
        
        Args:
            message: 日志消息
        """
        self.logger.debug(message)
    
    def info(self, message: str) -> None:
        """
        记录INFO级别日志
        
        Args:
            message: 日志消息
        """
        self.logger.info(message)
    
    def warning(self, message: str) -> None:
        """
        记录WARNING级别日志
        
        Args:
            message: 日志消息
        """
        self.logger.warning(message)
    
    def error(self, message: str) -> None:
        """
        记录ERROR级别日志
        
        Args:
            message: 日志消息
        """
        self.logger.error(message)
    
    def critical(self, message: str) -> None:
        """
        记录CRITICAL级别日志
        
        Args:
            message: 日志消息
        """
        self.logger.critical(message)


def setup_logging(
    config: Optional[Dict[str, Any]] = None, 
    name: str = 'k8s_extractor'
) -> Logger:
    """
    设置并返回日志记录器
    
    Args:
        config: 日志配置字典，可选
        name: 日志器名称
    
    Returns:
        配置好的日志管理器
    """
    return Logger(config, name)


# 模块级别的默认日志记录器
default_logger = setup_logging()


# 为其他模块提供方便的日志函数
def get_logger(name: Optional[str] = None) -> logging.Logger:
    """
    获取指定名称的日志记录器
    
    Args:
        name: 日志记录器名称，如果为None则使用默认名称
    
    Returns:
        日志记录器
    """
    if name:
        # 返回一个命名日志记录器，继承自默认日志记录器
        return logging.getLogger(name)
    else:
        # 返回默认日志记录器
        return default_logger.get_logger()
